// 数组转为数组对象
/**
 *
 * @param {*} arr 一个数组
 * @returns 数组对象
 */

const switchArrayToArOb = (arr) => {
    const newArrayList = [];
    for (const item in arr) {
        const obj = { value: arr[item] };
        newArrayList.push(obj);
    }
    return newArrayList;
};
// 银行卡输入4为后加空格
/**
 *
 * @param {*} evt evt对象
 */

const formatCardNumber = (evt) => {
    // 获取input的dom对象
    const input = evt.target;
    // 获取当前光标的位置
    const cursorIndex = input.selectionStart;
    // 字符串中光标之前空格的个数
    const lineNumOfCursorLeft = (evt.target.value.slice(0, cursorIndex).match(/\s/g) || []).length;
    // 去掉所有空格的字符串
    const noLine = evt.target.value.replace(/\s/g, '');
    // 去除格式不对的字符并重新插入空格的字符串
    const newCardNum = noLine
        .replace(/\D+/g, '')
        .replace(/(\d{4})/g, '$1 ')
        .replace(/\s$/, '');
    // 改后字符串中原光标之前空格的个数
    const newLineNumOfCursorLeft = (newCardNum.slice(0, cursorIndex).match(/\s/g) || []).length;
    // 光标在改后字符串中应在的位置
    const newCursorIndex = cursorIndex + newLineNumOfCursorLeft - lineNumOfCursorLeft;
    // 赋新值，nextTick保证空格不能手动输入或删除，只能按照规则自动填入
    this.$nextTick(() => {
        this.entity.bankCardNumber = newCardNum;
        // 修正光标位置，nextTick保证在渲染新值后定位光标
        this.$nextTick(() => {
            // selectionStart、selectionEnd分别代表选择一段文本时的开头和结尾位置
            input.selectionStart = newCursorIndex;
            input.selectionEnd = newCursorIndex;
        });
    });
};
// 处理价格数据，每三位加逗号，并留两位小数点（整数留 .00）
/**
 *
 * @param {*} num 数字
 * @returns 123,123,12
 */

const changeNumComma = (num) => {
    var f_x = parseFloat(num);
    if (isNaN(f_x)) {
        return 0;
    }
    var f_x = Math.round(x * 100) / 100;
    var s_x = f_x.toString();
    var pos_decimal = s_x.indexOf('.');
    if (pos_decimal < 0) {
        pos_decimal = s_x.length;
        s_x += '.';
    }
    while (s_x.length <= pos_decimal + 2) {
        s_x += '0';
    } // 三位加一个逗号
    s_x = Number(s_x).toLocaleString('en-US');
    return s_x;
    // changeTwoDecimal_f(123123.123) // "123123123.12"
    // changeTwoDecimal_f(123123) // "123123123.00"
};

// 两个数组拼接成一个数组对象形式
/**
 *
 * @param {*} arr1 数组1
 * @param {*} arr2 数组2
 * @returns 一个数组对象
 */

const doubleArrayToArOb = (arr1, arr2) => {
    let actionArr = [];
    for (let i = 0; i < arr1.length; i++) {
        let activeObj = {};
        for (let j = 0; j < arr2.length; j++) {
            if (i == j) {
                activeObj.name = arr1[i];
                activeObj.value = arr2[j];
                actionArr.push(activeObj);
            }
        }
    }
    return actionArr;
};

// 数组中有多个对象，去除对象相同的，计算多少组，返回一个数组出来
/**
 *
 * @param {*} list 数组
 * @returns 返回一个数组
 */
const removeArrObjSame = (list) => {
    let newList = [];
    newList = list.reduce((obj, item) => {
        let find = obj.find((i) => i.id === item.id);
        let _d = {
            ...item,
            frequency: 1,
        };
        find ? ((find.num += item.num), find.frequency++) : obj.push(_d);
        return obj;
    }, []);
    return newList;
};

// 将一个事件转换为时间戳
/**
 *
 * @param {*} times
 * @returns 毫秒时间戳
 */
const switchTimeStamp = (times) => {
    let date = new Date(times); //date日期类型
    let time = date.getTime();
    return time;
};

// 将字符串转为数组对象相同的对象key值   类似于switchArrayToArOb,
/**
 *
 * @param {*} arrList 一个数组
 * @param {*} keyValue 转换后为对象的key值
 * @returns 相同的对象key值
 */
const switchArrayToArObFun = (arrList, keyValue) => {
    let arr = [];
    arrList.split(',').forEach((item, index) => {
        let dataObj = {};
        dataObj.keyValue = item;
        arr.push(dataObj);
    });
    return arr;
};

// 时间的判定

const formatTime = (time, option) => {
    if (('' + time).length === 10) {
        time = parseInt(time) * 1000;
    } else {
        time = +time;
    }
    const d = new Date(time);
    const now = Date.now();

    const diff = (now - d) / 1000;

    if (diff < 30) {
        return '刚刚';
    } else if (diff < 3600) {
        // less 1 hour
        return Math.ceil(diff / 60) + '分钟前';
    } else if (diff < 3600 * 24) {
        return Math.ceil(diff / 3600) + '小时前';
    } else if (diff < 3600 * 24 * 2) {
        return '1天前';
    }
    if (option) {
        return parseTime(time, option);
    } else {
        return (
            d.getMonth() +
            1 +
            '月' +
            d.getDate() +
            '日' +
            d.getHours() +
            '时' +
            d.getMinutes() +
            '分'
        );
    }

    // let date = formatTime(new Date()) //输入时间
    // let date = formatTime(new Date().getTime()) //输入时间戳格式
    // console.log(new Date().getTime());
    // let date = formatTime(1615008130122) //输入某个时间戳
    // // let date = formatTime(new Date('2021-3-6 13:10:25'))
    // console.log(date); // 打印你想要的时间 比如 10分钟前 、3小时前 或者日期
};

// 时间的年月日 月份月初、月底、当前
/**
 *
 * @param {*} time  时间
 * @param {*} cFormat   格式
 * @returns 转换后的格式
 */
const parseTime = (time, cFormat) => {
    if (!time || arguments.length === 0) {
        return null;
    }
    const format = cFormat || '{y}-{m}-{d} {h}:{i}';
    let date;
    if (typeof time === 'object') {
        date = time;
    } else {
        if (typeof time === 'string' && /^[0-9]+$/.test(time)) {
            time = parseInt(time);
        }
        if (typeof time === 'number' && time.toString().length === 10) {
            time = time * 1000;
        }
        date = new Date(time);
    }
    const formatObj = {
        y: date.getFullYear(),
        m: date.getMonth() + 1,
        d: date.getDate(),
        h: date.getHours(),
        i: date.getMinutes(),
        s: date.getSeconds(),
        a: date.getDay(),
    };
    const time_str = format.replace(/{([ymdhisa])+}/g, (result, key) => {
        const value = formatObj[key];
        // Note: getDay() returns 0 on Sunday
        if (key === 'a') {
            return ['日', '一', '二', '三', '四', '五', '六'][value];
        }
        return value.toString().padStart(2, '0');
    });
    return time_str;

    //   // 测试如下：
    //   // 获取月份月初的年月日
    //   let data1 = parseTime(new Date().setDate(1), '{y}-{m}-{d}')
    //   console.log(data1); // 2021-03-01

    //   // 获取当天的年月日
    //   let data2 = parseTime(new Date(), '{y}-{m}-{d} {h}:{i}:{s} {a}')
    //   console.log(data2); // 2021-03-26 11:39:55 五

    //   // 获取当前月底年月日
    //   let date = new Date()
    //   yy = date.getFullYear()
    //   mm = date.getMonth() + 1
    //   let data3 = parseTime(new Date(yy, mm, 0), '{y}-{m}-{d}')
    //   console.log(data3); // 2021-03-31
};

// 去除数组对象对象中的空格
/**
 *
 * @param {*} list 数组对象或数组
 * @returns 去除空格后的数组或数组对象
 */
const removeArrObjSpace = (list) => {
    let newAnswer = [].forEach((item) => {
        // item.answer是一个数组对象
        list = item.answer.map((str) => {
            let res = str.replace(/\s+/g, '');
            return res;
        });
        newAnswer.push(item);
    });
    return newAnswer;
};

//删除数组中存在重复的元素
/**
 *
 * @param {*} someArray 存在相同元素的数组
 * @returns 删除后的数组
 */
const getUnique = (someArray) => {
    tempArray = someArray.slice(0); //复制数组到临时数组
    for (var i = 0; i < tempArray.length; i++) {
        for (var j = i + 1; j < tempArray.length; ) {
            if (tempArray[j] == tempArray[i]) {
                //后面的元素若和待比较的相同，则删除并计数；
                //删除后，后面的元素会自动提前，所以指针j不移动
                tempArray.splice(j, 1);
            } else {
                j++;
            }
            //不同，则指针移动
        }
    }
    return tempArray;
};

//判断数组中是否存在重复的元素
/**
 *
 * @param {*} someArray 存在相同元素的数组
 * @returns true 存在 false 不存在
 */
const confirmRepeat = (someArray) => {
    tempArray = someArray.slice(0); //复制数组到临时数组
    for (var i = 0; i < tempArray.length; i++) {
        for (var j = i + 1; j < tempArray.length; ) {
            if (tempArray[j] == tempArray[i]) {
                //后面的元素若和待比较的相同，则删除并计数；
                //删除后，后面的元素会自动提前，所以指针j不移动
                return true;
            } else {
                j++;
            }
            //不同，则指针移动
        }
    }
    return false;
};

//金额大写转换函数 transform('123431233132.23')
/**
 *
 * @param {*} tranvalue 数字金额
 * @returns
 */
const transform = (tranvalue) => {
    try {
        var i = 1;
        var dw2 = new Array('', '万', '亿'); //大单位
        var dw1 = new Array('拾', '佰', '仟'); //小单位
        var dw = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'); //整数部分用
        //以下是小写转换成大写显示在合计大写的文本框中
        //分离整数与小数
        var source = splits(tranvalue);
        var num = source[0];
        var dig = source[1];
        //转换整数部分
        var k1 = 0; //计小单位
        var k2 = 0; //计大单位
        var sum = 0;
        var str = '';
        var len = source[0].length; //整数的长度
        for (i = 1; i <= len; i++) {
            var n = source[0].charAt(len - i); //取得某个位数上的数字
            var bn = 0;
            if (len - i - 1 >= 0) {
                bn = source[0].charAt(len - i - 1); //取得某个位数前一位上的数字
            }
            sum = sum + Number(n);
            if (sum != 0) {
                str = dw[Number(n)].concat(str); //取得该数字对应的大写数字，并插入到str字符串的前面
                if (n == '0') sum = 0;
            }
            if (len - i - 1 >= 0) {
                //在数字范围内
                if (k1 != 3) {
                    //加小单位
                    if (bn != 0) {
                        str = dw1[k1].concat(str);
                    }
                    k1++;
                } else {
                    //不加小单位，加大单位
                    k1 = 0;
                    var temp = str.charAt(0);
                    if (temp == '万' || temp == '亿')
                        //若大单位前没有数字则舍去大单位
                        str = str.substr(1, str.length - 1);
                    str = dw2[k2].concat(str);
                    sum = 0;
                }
            }
            if (k1 == 3) {
                //小单位到千则大单位进一
                k2++;
            }
        }
        //转换小数部分
        var strdig = '';
        if (dig != '') {
            var n = dig.charAt(0);
            if (n != 0) {
                strdig += dw[Number(n)] + '角'; //加数字
            }
            var n = dig.charAt(1);
            if (n != 0) {
                strdig += dw[Number(n)] + '分'; //加数字
            }
        }
        str += '元' + strdig;
    } catch (e) {
        return '0元';
    }
    return str;
};

// 元素拖拽
/**
 *
 * @param {*} e evt对象
 */
const move = (e) => {
    let odiv = e.target; //获取目标元素
    //算出鼠标相对元素的位置
    let disX = e.clientX - odiv.offsetLeft;
    let disY = e.clientY - odiv.offsetTop;
    document.onmousemove = (e) => {
        //鼠标按下并移动的事件
        //用鼠标的位置减去鼠标相对元素的位置，得到元素的位置
        let left = e.clientX - disX;
        let top = e.clientY - disY;
        //移动当前元素
        odiv.style.left = left + 'px';
        odiv.style.top = top + 'px';
    };
    document.onmouseup = (e) => {
        document.onmousemove = null;
        document.onmouseup = null;
    };
};
// 生成随机数
/**
 *
 * @param {*} min   最小值
 * @param {*} max   最大值
 * @returns
 */
const randomNum = (min, max) => {
    return min + Math.random() * (max - min + 1);
};

//封装鼠标拖拽
/**
 *
 * @param {*} node node节点
 */
const drag = (node) => {
    node.onmousedown = function (ev) {
        var e = ev || window.event;
        //记录相对位置
        var offsetX = e.clientX - node.offsetLeft;
        var offsetY = e.clientY - node.offsetTop;
        //添加鼠标移动事件
        document.onmousemove = function (ev) {
            var e = ev || window.event;
            node.style.left = e.clientX - offsetX + 'px';
            node.style.top = e.clientY - offsetY + 'px';
        };
    };
    //鼠标抬起取消拖拽
    document.onmouseup = function () {
        document.onmousemove = null;
    };
};

//封装鼠标拖拽限制区域
/**
 *
 * @param {*} node node节点
 */
const dragLimit = (node) => {
    node.onmousedown = function (ev) {
        var e = ev || window.event;
        //记录相对位置
        var offsetX = e.clientX - node.offsetLeft;
        var offsetY = e.clientY - node.offsetTop;
        //添加鼠标移动事件
        document.onmousemove = function (ev) {
            var e = ev || window.event;
            var l = e.clientX - offsetX;
            var t = e.clientY - offsetY;

            if (l <= 0) {
                l = 0;
            }
            var windowWidth = document.documentElement.clientWidth || document.body.clientWidth;
            if (l >= windowWidth - node.offsetWidth) {
                l = windowWidth - node.offsetWidth;
            }

            var windowHeight = document.documentElement.clientHeight || document.body.clientHeight;
            if (t <= 0) {
                t = 0;
            }
            if (t >= windowHeight - node.offsetHeight) {
                t = windowHeight - node.offsetHeight;
            }

            node.style.left = l + 'px';
            node.style.top = t + 'px';
        };
    };
    //鼠标抬起取消拖拽
    document.onmouseup = function () {
        document.onmousemove = null;
    };
};

//封装获取随机颜色的方法
/**
 * 返回一个ragb形式的随机颜色值
 * @returns
 */
const randomColor = () => {
    var str =
        'rgba(' +
        parseInt(Math.random() * 256) +
        ',' +
        parseInt(Math.random() * 256) +
        ',' +
        parseInt(Math.random() * 256) +
        ',1)';
    return str;
};

// 封装一个随机颜色值
/**
 * 返回一个16机制颜色的随机颜色值
 * @returns
 */
const getRandomColorSixSystem = () => {
    var result = '#';
    var arr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'];

    for (var i = 0; i < 6; i++) {
        var index = parseInt(Math.random() * 16);
        result = result + arr[index];
    }

    return result;
};
// 封装数字转为字符码
/**
 *
 * @param {*} n 一个数字
 * @returns
 */
const testCode = (n) => {
    var arr = [];
    for (var i = 0; i < n; i++) {
        var tmp = parseInt(Math.random() * 123);
        if (tmp >= 0 && tmp <= 9) {
            arr.push(tmp);
        } else if ((tmp >= 97 && tmp <= 122) || (tmp >= 65 && tmp <= 90)) {
            arr.push(String.fromCharCode(tmp));
        } else {
            //没有用的数，也会占用我的循环次数
            i--;
        }
    }

    return arr.join('');
};
// 封装转码数字
/**
 *
 * @param {*} n 一个数字
 * @returns
 */
const testCodeNum = (n) => {
    var arr = [];
    for (var i = 0; i < n; i++) {
        var tmp = parseInt(Math.random() * 10);
        arr.push(tmp);
    }
    return arr.join('');
};

//封装升序
const bubbleSort = (arr) => {
    //通过冒泡排序从小到大排序
    for (var i = 0; i < arr.length - 1; i++) {
        //每一轮比较的次数
        for (var j = 0; j < arr.length - (i + 1); j++) {
            if (arr[j] > arr[j + 1]) {
                var tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
};
//封装两数比较大小
const changeSort = (arr) => {
    //当前的擂台
    for (var i = 0; i < arr.length - 1; i++) {
        //被比较的数
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                var tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
};
//封装数组去重方法
const noRepeat = (arr) => {
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) {
                arr.splice(j, 1);
                j--;
            }
        }
    }
};
//封装数组去重方法2
const noRepeatTwo = (arr) => {
    for (var i = arr.length - 1; i > 0; i--) {
        for (var j = i - 1; j >= 0; j--) {
            if (arr[i] == arr[j]) {
                arr.splice(j, 1);
            }
        }
    }
};

export default {
    switchArrayToArOb,
    formatCardNumber,
    changeNumComma,
    doubleArrayToArOb,
    removeArrObjSame,
    switchTimeStamp,
    switchArrayToArObFun,
    formatTime,
    parseTime,
    removeArrObjSpace,
    getUnique,
    confirmRepeat,
    transform,
    move,
    randomNum,
    drag,
    dragLimit,
    randomColor,
    getRandomColorSixSystem,
    testCode,
    testCodeNum,
    bubbleSort,
    changeSort,
    noRepeat,
    noRepeatTwo,
};
